home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xgrabsc / xgrabxm.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-09  |  17.1 KB  |  704 lines
  1. /*========================================================================
  2.  *
  3.  * Name - xgrabxm.c
  4.  *
  5.  * Version:    1.5
  6.  *
  7.  * ccsid:    @(#)xgrabxm.c    1.5 -06/28/93 09:13:55
  8.  * from:     ccs/s.xgrabxm.c
  9.  * date:     06/28/93 09:14:49
  10.  *
  11.  * Copyright (c) 1990-93 Bruce Schuchardt.
  12.  * Read the file cpyright.h for full copyright information.
  13.  *
  14.  *
  15.  * Description:
  16.  *
  17.  * xgrab.c - interactive front for xgrabsc
  18.  *
  19.  *========================================================================
  20.  */
  21. #include "cpyright.h"
  22. #include "patchlevel.h"
  23. #include "config.h"
  24.  
  25. #include <stdio.h>
  26. #include <X11/Intrinsic.h>
  27. #include <X11/StringDefs.h>
  28. #include <X11/Shell.h>
  29. #include <Xm/Xm.h>
  30. #include <Xm/Form.h>
  31. #include <Xm/Label.h>
  32. #include <Xm/PushB.h>
  33. #include <Xm/RowColumn.h>
  34. #include <Xm/ToggleB.h>
  35. #include <Xm/Text.h>
  36.  
  37. static char *fallback_resources[] = {
  38. #include "xgrabxm_ad.h"
  39.   NULL
  40.   };
  41.  
  42.  
  43. static Display *hDisplay;
  44.  
  45. typedef enum {
  46.   HITWIN = 1,
  47.   STRETCH,
  48.   KEY,
  49.   ROOT,
  50.  
  51.   XWD,
  52.   XWDXY,
  53.   PS,
  54.   BITMAP,
  55.   BITMAP2,
  56.   BITMAP3,
  57.   PUZZLE,
  58.   SIMPLE,
  59.  
  60.   NO_DITHER,
  61.   DITHER,
  62.   MDITHER,
  63.   HALFTONE,
  64.   MAPBW,
  65.  
  66.   REVERSE,
  67.  
  68.   TOFILE,
  69.   TOPRN,
  70.  
  71.   PS_NORMAL,
  72.   PS_EPS,
  73.   PS_EPSI,
  74.   PS_EPSIONLY,
  75.   PS_LANDSCAPE
  76.   
  77.   } radioType;
  78.  
  79. radioType encValue = PS_NORMAL;
  80. radioType cnvValue = NO_DITHER;
  81. radioType selValue = STRETCH;
  82. radioType fmtValue = PS;
  83. radioType outValue = TOFILE;
  84.  
  85.  
  86.  
  87. void encValueChanged(widget, newValue, tag)
  88.   Widget widget;
  89.   void *tag;
  90.   radioType newValue;
  91. {
  92.   if (newValue == encValue) /* turning it off */
  93.     encValue = PS_NORMAL;
  94.   else
  95.     encValue = newValue;
  96. }
  97.  
  98.  
  99. void cnvValueChanged(widget, newValue, tag)
  100.   Widget widget;
  101.   void *tag;
  102.   radioType newValue;
  103. {
  104.   if (newValue == cnvValue) /* turning it off */
  105.     cnvValue = NO_DITHER;
  106.   else
  107.     cnvValue = newValue;
  108. }
  109.  
  110.  
  111. void selValueChanged(widget, newValue, tag)
  112.   Widget widget;
  113.   void *tag;
  114.   radioType newValue;
  115. {
  116.   radioType oldValue = selValue;
  117.   
  118.   if (newValue == selValue) /* turning it off */
  119.     selValue = STRETCH;
  120.   else
  121.     selValue = newValue;
  122. #ifdef DEBUGGING
  123.   fprintf(stderr, "old sel value = %d   new = %d\n", oldValue, selValue);
  124. #endif
  125. }
  126.  
  127. void fmtValueChanged(widget, newValue, tag)
  128.   Widget widget;
  129.   void *tag;
  130.   radioType newValue;
  131. {
  132.   if (newValue == fmtValue) /* turning it off */
  133.     fmtValue = PS;
  134.   else
  135.     fmtValue = newValue;
  136. }
  137.  
  138. void outValueChanged(widget, newValue, tag)
  139.   Widget widget;
  140.   void *tag;
  141.   radioType newValue;
  142. {
  143.   if (newValue == encValue) /* turning it off */
  144.     outValue = TOFILE;
  145.   else
  146.     outValue = newValue;
  147. }
  148.  
  149.  
  150. Widget selBtns, formatBtns, psColr, encBtns, psComp, sltext, psltext,
  151.        psLim, 
  152.        psBin, borderBtn, horizMargin, vertMargin, pgHeight, pgWidth,
  153.        cnvBtns, revBtn, brtext, outBtns, filenm, prncmd, dispBtn, hostnm;
  154. Widget hShell;
  155.  
  156. XtAppContext appContext;
  157.  
  158.  
  159. static char* stradi(ptr, i)    /* Add an integer to a string */
  160.     char* ptr;
  161.     int i; {
  162.  
  163.     sprintf(ptr + strlen(ptr), "%d", i);
  164.     return ptr;
  165. }
  166.  
  167. static char* stradw(ptr, s)   /* Add a string to another, with no ws */
  168.     char* ptr;
  169.     char* s; {
  170.  
  171.     char* ou = ptr + strlen(ptr);
  172.  
  173.     while (isspace(*s)) {
  174.     ++s;
  175.     }
  176.     while (*s && !isspace(*s)) {
  177.     *ou++ = *s++;
  178.     }
  179.     *ou = '\0';
  180.  
  181.     return ptr;
  182. }
  183.  
  184.  
  185. static void doGrab() {
  186.   char tmp[257];
  187.   char cmdargs[200];
  188.   char piper[200];
  189.   char cmd[500];
  190.   char *txt;
  191.   int  s, d, len, num;
  192.   int  sltime, psltime;
  193.   int  bright;
  194.   Boolean state;
  195.  
  196.   cmdargs[0] = '\0';
  197.   piper[0] = '\0';
  198.  
  199.   XtVaGetValues(sltext, XmNvalue, &txt, NULL);
  200.   sltime = atoi(txt);
  201.   if (sltime < 0) sltime = 0;
  202.   sprintf(tmp, "-sleep %d ", sltime);
  203.   strcat(cmdargs, tmp);
  204.  
  205.   XtVaGetValues(psltext, XmNvalue, &txt, NULL);
  206.   psltime = atoi(txt);
  207.   if (psltime < 0) psltime = 0;
  208.   sprintf(tmp, "-post %d ", psltime);
  209.   strcat(cmdargs, tmp);
  210.  
  211.   XtVaGetValues(brtext, XmNvalue, &txt, NULL);
  212.   bright = atoi(txt);
  213.   sprintf(tmp, "-brighten %d ", bright);
  214.   strcat(cmdargs, tmp);
  215.  
  216.   XtVaGetValues(borderBtn, XmNset, &state, NULL);
  217.   if (!state)
  218.     strcat(cmdargs, "-");
  219.   strcat(cmdargs, "-bdrs ");
  220.  
  221.   XtVaGetValues(revBtn, XmNset, &state, NULL);
  222.   if (!state)
  223.     strcat(cmdargs, "-");
  224.   strcat(cmdargs, "-reverse ");
  225.  
  226.   switch (selValue) {
  227.     case HITWIN:
  228.       strcat(cmdargs, "-click ");
  229.       break;
  230.     case KEY:
  231.       strcat(cmdargs, "-key ");
  232.       break;
  233.     case ROOT:
  234.       strcat(cmdargs, "-root ");
  235.       break;
  236.     case STRETCH:
  237.     default:
  238.       strcat(cmdargs, "-stretch ");
  239.       break;
  240.   }
  241.   switch (fmtValue) {
  242.     case XWD:
  243.       strcat(cmdargs, "-xwd ");
  244.       break;
  245.     case XWDXY:
  246.       strcat(cmdargs, "-xwdxy ");
  247.       break;
  248.     case BITMAP:
  249.       strcat(cmdargs, "-bm ");
  250.       break;
  251.     case BITMAP2:
  252.       strcat(cmdargs, "-bm2 ");
  253.       break;
  254.     case BITMAP3:
  255.       strcat(cmdargs, "-bm3 ");
  256.       break;
  257.     case PUZZLE:
  258.       strcat(cmdargs, "-puzzle ");
  259.       break;
  260.     case SIMPLE:
  261.       strcat(cmdargs, "-simple ");
  262.       break;
  263.     case PS:
  264.     default:
  265.       XtVaGetValues(psColr, XmNset, &state, NULL);
  266.       if (!state)
  267.         strcat(cmdargs, "-ps ");
  268.       else
  269.         strcat(cmdargs, "-cps ");
  270.  
  271.       switch (encValue) {
  272.         case PS_EPS:
  273.           strcat(cmdargs, "-eps ");
  274.       break;
  275.     case PS_EPSI:
  276.       strcat(cmdargs, "-preview ");
  277.       break;
  278.     case PS_EPSIONLY:
  279.       strcat(cmdargs, "-previewonly ");
  280.       break;
  281.     case PS_LANDSCAPE:
  282.       strcat(cmdargs, "-landscape ");
  283.       break;
  284.     default:
  285.       break;
  286.       }
  287.  
  288.       XtVaGetValues(psComp, XmNset, &state, NULL);
  289.       if (!state)
  290.         strcat(cmdargs, "-");
  291.       strcat(cmdargs, "-compress ");
  292.       XtVaGetValues(psBin, XmNset, &state, NULL);
  293.       if (!state)
  294.         strcat(cmdargs, "-");
  295.       strcat(cmdargs, "-bin ");
  296.  
  297.       XtVaGetValues(psLim, XmNset, &state, NULL);
  298.       if (!state)
  299.         strcat(cmdargs, "-");
  300.       strcat(cmdargs, "-limit ");
  301.  
  302.       strcat(cmdargs, "-page ");
  303.       XtVaGetValues(pgWidth, XmNvalue, &txt, NULL);
  304.       if (strlen(txt))    stradw(cmdargs, txt);
  305.       else                stradi(cmdargs, PAPER_WIDTH);
  306.       strcat(cmdargs, "x");
  307.       XtVaGetValues(pgHeight, XmNvalue, &txt, NULL);
  308.       if (strlen(txt))    stradw(cmdargs, txt);
  309.       else                stradi(cmdargs, PAPER_HEIGHT);
  310.       strcat(cmdargs, "-");
  311.       XtVaGetValues(horizMargin, XmNvalue, &txt, NULL);
  312.       if (strlen(txt))    stradw(cmdargs, txt);
  313.       else                stradi(cmdargs, HORIZ_MARGIN);
  314.       strcat(cmdargs, "-");
  315.       XtVaGetValues(horizMargin, XmNvalue, &txt, NULL);
  316.       if (strlen(txt))    stradw(cmdargs, txt);
  317.       else                stradi(cmdargs, VERT_MARGIN);
  318.       strcat(cmdargs, " ");
  319.  
  320.       break;
  321.   }
  322.   switch (cnvValue) {
  323.     case DITHER:
  324.       strcat(cmdargs, "-dither ");
  325.       break;
  326.     case MDITHER:
  327.       strcat(cmdargs, "-mdither ");
  328.       break;
  329.     case HALFTONE:
  330.       strcat(cmdargs, "-halftone ");
  331.       break;
  332.     case MAPBW:
  333.       strcat(cmdargs, "-bw ");
  334.       break;
  335.     default:
  336.       break;
  337.   }
  338.   switch (outValue) {
  339.     case TOPRN:
  340.       XtVaGetValues(prncmd, XmNvalue, &txt, NULL);
  341.       if (strlen(txt)) {
  342.         strcat(piper, " | ");
  343.         strcat(piper, txt);
  344.       }
  345.       break;
  346.     case TOFILE:
  347.     default:
  348.       strcat(cmdargs, "-o ");
  349.       XtVaGetValues(filenm, XmNvalue, &txt, NULL);
  350.       if (strlen(txt)) {
  351.         strcat(cmdargs, txt);
  352. #ifdef BUMP_FILENAMES
  353.     len = strlen(txt);
  354.     for (s=0; s<len && (txt[s] != '.'); s++)
  355.     {}
  356.     strcpy(tmp, txt);
  357.     tmp[s] = '\0';
  358.     d = s;
  359.     while (d > 0  &&  ('0' <= txt[d-1]  &&  txt[d-1] <= '9'))
  360.       d--;
  361.     if ('0' <= txt[d]  && txt[d] <= '9')
  362.       num = atoi(&tmp[d]);
  363.     else
  364.       num = 0;
  365.     num++;
  366.     sprintf(&tmp[d], "%d", num);
  367.     strcat(tmp, &txt[s]);
  368.     XtVaSetValues(filenm, XmNvalue, tmp, NULL);
  369. #endif
  370.       }
  371.       else {
  372.         strcat(cmdargs, "screen.dmp");
  373.     XtVaSetValues(filenm, XmNvalue, "screen.dmp", NULL);
  374.       }
  375.       strcat(cmdargs, " ");
  376.       break;
  377.   }
  378.  
  379.   XtVaGetValues(dispBtn, XmNset, &state, NULL);
  380.   if (state) {
  381.     XtVaGetValues(hostnm, XmNvalue, &txt, NULL);
  382.     strcat(cmdargs, "-d ");
  383.     if (strlen(txt)) {
  384.       strcat(cmdargs, txt);
  385.       strcat(cmdargs, " ");
  386.     }
  387.     else
  388.       strcat(cmdargs, ":0 ");
  389.   }
  390.  
  391.   sprintf(cmd, "xgrabsc %s%s\n", cmdargs, piper);
  392. #ifdef DEBUGGING
  393.   fputs(cmd, stderr);
  394. #else
  395.   /* try to make the window iconic */
  396.   XtUnmapWidget(hShell);
  397.   XSync(hDisplay, False);
  398.   system(cmd);
  399.   XtMapWidget(hShell);
  400. #endif
  401. }
  402.  
  403.  
  404.  
  405.  
  406. static void doDismiss() {
  407.   if (hShell) {
  408.     XtDestroyWidget(hShell);
  409.     hShell = NULL;
  410.     exit(0);
  411.   }
  412. }
  413.  
  414.  
  415.  
  416.  
  417. static void createWindow() {
  418.   Widget dialog, button, box1, box2, box3, box4, box5, box6;
  419.  
  420.   dialog = XtVaCreateManagedWidget("dialog", xmFormWidgetClass, hShell,
  421.            NULL);
  422.            XtVaCreateManagedWidget("title",  xmLabelWidgetClass, dialog,
  423.            NULL);
  424.  
  425.  
  426.   /* selection options */
  427.   /* input options */
  428.   box1 = XtVaCreateManagedWidget("box1", xmFormWidgetClass, dialog, NULL);
  429.  
  430.            XtVaCreateManagedWidget("inputLbl", xmLabelWidgetClass, box1,
  431.        NULL);
  432.  
  433.   dispBtn= XtVaCreateManagedWidget("host", xmToggleButtonWidgetClass, box1,
  434.        NULL);
  435.  
  436.   hostnm = XtVaCreateManagedWidget("hostText", xmTextWidgetClass, box1,
  437.            NULL);
  438.  
  439.   if (getenv("DISPLAY"))
  440.     XtVaSetValues(hostnm, XmNvalue, getenv("DISPLAY"), NULL);
  441.  
  442.   selBtns = XmCreateRadioBox(box1, "selectiontype", NULL, 0);
  443.            XtManageChild(selBtns);
  444.        
  445.   button = XtVaCreateManagedWidget("click", xmToggleButtonWidgetClass, selBtns,
  446.        NULL);
  447.            XtAddCallback(button, XmNvalueChangedCallback, selValueChanged,
  448.        HITWIN);
  449.  
  450.   button = XtVaCreateManagedWidget("stretch", xmToggleButtonWidgetClass, selBtns,
  451.        NULL);
  452.            XtAddCallback(button, XmNvalueChangedCallback, selValueChanged,
  453.        STRETCH);
  454.  
  455.   button = XtVaCreateManagedWidget("key", xmToggleButtonWidgetClass, selBtns,
  456.        NULL);
  457.            XtAddCallback(button, XmNvalueChangedCallback, selValueChanged,
  458.        KEY);
  459.  
  460.   button = XtVaCreateManagedWidget("root", xmToggleButtonWidgetClass, selBtns,
  461.        NULL);
  462.            XtAddCallback(button, XmNvalueChangedCallback, selValueChanged,
  463.        ROOT);
  464.  
  465.            XtVaCreateManagedWidget("sleeplbl", xmLabelWidgetClass, box1,
  466.            NULL);
  467.  
  468.   sltext = XtVaCreateManagedWidget("sleeptime", xmTextWidgetClass, box1,
  469.            NULL);
  470.  
  471.            XtVaCreateManagedWidget("psleeplbl", xmLabelWidgetClass, box1,
  472.            NULL);
  473.  
  474.   psltext = XtVaCreateManagedWidget("psleeptime", xmTextWidgetClass, box1,
  475.            NULL);
  476.  
  477.   box2 = XtVaCreateManagedWidget("box2", xmFormWidgetClass, dialog, NULL);
  478.  
  479.   /* output options */
  480.            XtVaCreateManagedWidget("outputFormat", xmLabelWidgetClass, box2,
  481.            NULL);
  482.  
  483.   formatBtns = XmCreateRadioBox(box2, "formattype", NULL, 0);
  484.        XtManageChild(formatBtns);
  485.        
  486.   button = XtVaCreateManagedWidget("xwd", xmToggleButtonWidgetClass, formatBtns,
  487.        NULL);
  488.            XtAddCallback(button, XmNvalueChangedCallback, fmtValueChanged,
  489.        XWD);
  490.  
  491.   button = XtVaCreateManagedWidget("xwdxy", xmToggleButtonWidgetClass, formatBtns,
  492.        NULL);
  493.            XtAddCallback(button, XmNvalueChangedCallback, fmtValueChanged,
  494.        XWDXY);
  495.  
  496.   button = XtVaCreateManagedWidget("ps", xmToggleButtonWidgetClass, formatBtns,
  497.        NULL);
  498.            XtAddCallback(button, XmNvalueChangedCallback, fmtValueChanged,
  499.        PS);
  500.  
  501.   button = XtVaCreateManagedWidget("xpm", xmToggleButtonWidgetClass, formatBtns,
  502.        NULL);
  503.            XtAddCallback(button, XmNvalueChangedCallback, fmtValueChanged,
  504.        BITMAP);
  505.  
  506.   button = XtVaCreateManagedWidget("xpm2", xmToggleButtonWidgetClass, formatBtns,
  507.        NULL);
  508.            XtAddCallback(button, XmNvalueChangedCallback, fmtValueChanged,
  509.        BITMAP2);
  510.  
  511.   button = XtVaCreateManagedWidget("xpm3", xmToggleButtonWidgetClass, formatBtns,
  512.        NULL);
  513.            XtAddCallback(button, XmNvalueChangedCallback, fmtValueChanged,
  514.        BITMAP3);
  515.  
  516.   button = XtVaCreateManagedWidget("puzzle", xmToggleButtonWidgetClass, formatBtns,
  517.        NULL);
  518.            XtAddCallback(button, XmNvalueChangedCallback, fmtValueChanged,
  519.        PUZZLE);
  520.  
  521.  
  522.  
  523.   /* postscript options */
  524.   box3 = XtVaCreateManagedWidget("box3", xmFormWidgetClass, dialog, NULL);
  525.  
  526.            XtVaCreateManagedWidget("psOptions", xmLabelWidgetClass, box3,
  527.            NULL);
  528.  
  529.   psComp = XtVaCreateManagedWidget("compress", xmToggleButtonWidgetClass, box3,
  530.        NULL);
  531.  
  532.   psColr = XtVaCreateManagedWidget("color", xmToggleButtonWidgetClass, box3,
  533.        NULL);
  534.  
  535.            XtVaCreateManagedWidget("pageWidth", xmLabelWidgetClass, box3,
  536.            NULL);
  537.  
  538.   pgWidth = XtVaCreateManagedWidget("pageWidthText",xmTextWidgetClass, box3,
  539.            NULL);
  540.  
  541.            XtVaCreateManagedWidget("pageHeight", xmLabelWidgetClass, box3,
  542.            NULL);
  543.  
  544.   pgHeight = XtVaCreateManagedWidget("pageHeightText",xmTextWidgetClass, box3,
  545.            NULL);
  546.  
  547.            XtVaCreateManagedWidget("horizMargin", xmLabelWidgetClass, box3,
  548.            NULL);
  549.  
  550.   horizMargin = XtVaCreateManagedWidget("horizMarginText",xmTextWidgetClass, box3,
  551.            NULL);
  552.  
  553.            XtVaCreateManagedWidget("vertMargin", xmLabelWidgetClass, box3,
  554.            NULL);
  555.  
  556.   vertMargin = XtVaCreateManagedWidget("vertMarginText",xmTextWidgetClass, box3,
  557.            NULL);
  558.  
  559.  
  560.   encBtns = XmCreateRadioBox(box3, "postscripttype", NULL, 0);
  561.        XtManageChild(encBtns);
  562.        
  563.   button = XtVaCreateManagedWidget("portrait", xmToggleButtonWidgetClass, encBtns,
  564.        NULL);
  565.            XtAddCallback(button, XmNvalueChangedCallback, encValueChanged,
  566.        PS_NORMAL);
  567.  
  568.   button = XtVaCreateManagedWidget("landscape", xmToggleButtonWidgetClass, encBtns,
  569.        NULL);
  570.            XtAddCallback(button, XmNvalueChangedCallback, encValueChanged,
  571.        PS_LANDSCAPE);
  572.  
  573.   button = XtVaCreateManagedWidget("epsi", xmToggleButtonWidgetClass, encBtns,
  574.        NULL);
  575.            XtAddCallback(button, XmNvalueChangedCallback, encValueChanged,
  576.        PS_EPSI);
  577.  
  578. /*------------
  579.   button = XtVaCreateManagedWidget("encap", xmToggleButtonWidgetClass, encBtns,
  580.        NULL);
  581.            XtAddCallback(button, XmNvalueChangedCallback, encValueChanged,
  582.        PS_EPS);
  583. ---------------*/
  584.  
  585.   button = XtVaCreateManagedWidget("onlyEpsi", xmToggleButtonWidgetClass, encBtns,
  586.        NULL);
  587.            XtAddCallback(button, XmNvalueChangedCallback, encValueChanged,
  588.        PS_EPSIONLY);
  589.  
  590.   psBin = XtVaCreateManagedWidget("binary", xmToggleButtonWidgetClass, box3,
  591.        NULL);
  592.  
  593.   psLim = XtVaCreateManagedWidget("limit", xmToggleButtonWidgetClass, box3,
  594.        NULL);
  595.  
  596.  
  597.   /* image processing options */
  598.   box4 = XtVaCreateManagedWidget("box4", xmFormWidgetClass, dialog, NULL);
  599.  
  600.            XtVaCreateManagedWidget("prOptions", xmLabelWidgetClass, box4,
  601.            NULL);
  602.  
  603.            XtVaCreateManagedWidget("brightnessLbl", xmLabelWidgetClass, box4,
  604.        NULL);
  605.   brtext = XtVaCreateManagedWidget("brightnessText", xmTextWidgetClass, box4,
  606.            NULL);
  607.  
  608.   revBtn = XtVaCreateManagedWidget("reverse", xmToggleButtonWidgetClass, box4, NULL);
  609.  
  610.   borderBtn = XtVaCreateManagedWidget("borders", xmToggleButtonWidgetClass, box4, NULL);
  611.  
  612.  
  613.   box5 = XtVaCreateManagedWidget("box5", xmFormWidgetClass, dialog, NULL);
  614.  
  615.            XtVaCreateManagedWidget("outputLbl", xmLabelWidgetClass, box5,
  616.        NULL);
  617.  
  618.   outBtns = XmCreateRadioBox(box5, "outputtype", NULL, 0);
  619.        XtManageChild(outBtns);
  620.  
  621.  
  622.   button = XtVaCreateManagedWidget("file", xmToggleButtonWidgetClass, outBtns,
  623.        NULL);
  624.            XtAddCallback(button, XmNvalueChangedCallback, outValueChanged,
  625.        TOFILE);
  626.  
  627.   filenm = XtVaCreateManagedWidget("fileText", xmTextWidgetClass, box5,
  628.            NULL);
  629.  
  630.   button = XtVaCreateManagedWidget("printer", xmToggleButtonWidgetClass, outBtns,
  631.        NULL);
  632.            XtAddCallback(button, XmNvalueChangedCallback, outValueChanged,
  633.        TOPRN);
  634.  
  635.   prncmd = XtVaCreateManagedWidget("printerText", xmTextWidgetClass, box5,
  636.            NULL);
  637.  
  638.  
  639.   cnvBtns = XmCreateRadioBox(dialog, "converttype", NULL, 0);
  640.  
  641.            XtVaSetValues(cnvBtns,
  642.        XmNorientation, XmHORIZONTAL,
  643.        NULL);
  644.        XtManageChild(cnvBtns);
  645.        
  646.   button = XtVaCreateManagedWidget("nodither", xmToggleButtonWidgetClass, cnvBtns,
  647.        NULL);
  648.            XtAddCallback(button, XmNvalueChangedCallback, cnvValueChanged,
  649.        NO_DITHER);
  650.  
  651.   button = XtVaCreateManagedWidget("dither", xmToggleButtonWidgetClass, cnvBtns,
  652.        NULL);
  653.            XtAddCallback(button, XmNvalueChangedCallback, cnvValueChanged,
  654.        DITHER);
  655.  
  656.   button = XtVaCreateManagedWidget("mdither", xmToggleButtonWidgetClass, cnvBtns,
  657.        NULL);
  658.            XtAddCallback(button, XmNvalueChangedCallback, cnvValueChanged,
  659.        MDITHER);
  660.  
  661.   button = XtVaCreateManagedWidget("halftone", xmToggleButtonWidgetClass, cnvBtns,
  662.        NULL);
  663.            XtAddCallback(button, XmNvalueChangedCallback, cnvValueChanged,
  664.        HALFTONE);
  665.  
  666.   button = XtVaCreateManagedWidget("mapbw", xmToggleButtonWidgetClass, cnvBtns,
  667.        NULL);
  668.            XtAddCallback(button, XmNvalueChangedCallback, cnvValueChanged,
  669.        MAPBW);
  670.  
  671.   box6 = XtVaCreateManagedWidget("box6", xmFormWidgetClass, dialog, NULL);
  672.  
  673.   XtVaCreateManagedWidget("splat", xmLabelWidgetClass, box6, NULL);
  674.   
  675.   button = XtVaCreateManagedWidget("OK", xmPushButtonWidgetClass, box6, NULL);
  676.   XtAddCallback(button, XmNactivateCallback, doGrab, NULL);
  677.  
  678.   button = XtVaCreateManagedWidget("Dismiss", xmPushButtonWidgetClass, box6, NULL);
  679.   XtAddCallback(button, XmNactivateCallback, doDismiss, NULL);
  680.  
  681. }
  682.  
  683.  
  684.  
  685. int main(argc, argv, envp)
  686.   int argc;
  687.   char *argv[];
  688.   char *envp;
  689. {
  690.   puts("X-Windows Screen Grabber");
  691.   puts(Copyright);
  692.   puts("");
  693.  
  694.  
  695.   hShell = XtAppInitialize(&appContext, "XGrab", NULL, 0, &argc, argv,
  696.      fallback_resources, NULL, 0);
  697.  
  698.   hDisplay = XtDisplay(hShell);
  699.   createWindow();
  700.  
  701.   XtRealizeWidget(hShell);
  702.   XtAppMainLoop(appContext);
  703. }
  704.